import React, { useState, useEffect } from 'react';
import axios from 'axios';
import { Toast } from 'antd-mobile';
import { R , VOID} from "@/assets/js/dict.js"

//  .defaults.headers.common['token'] = store.state.token;
axios.defaults.retry = 4;
axios.defaults.retryDelay = 1000;
axios.defaults.withCredentials = true; //让ajax携带cookie

if (process.env.NODE_ENV === "development") {
    axios.defaults.baseURL = '/'
} else {
    axios.defaults.baseURL = '/'
}

axios.interceptors.request.use(config => {
    // console.log('config --------->>>', config)
    let token = localStorage.getItem('token');
    if (token) {
        config.headers.Authorization = token;
    }
    return config;
}, err => {
    console.log('err --------->>>', err);
    return Promise.reject(err);
});

// http response 服务器响应拦截器，这里拦截401错误，并重新跳入登页重新获取token
axios.interceptors.response.use(
    response => {
        const res = response.data;
        let au = response.headers.authorization;
        if (au) {
            localStorage.setItem('token', au);
        }
        if (!R.isSuccess(res)) {
            if (R.fail === res.code) {
                Toast.fail(<div>
                    <p>
                        {res.message}
                    </p>
                </div>, 3, VOID, false);
                return res;
            } else {
                Toast.offline(res.message? res.message: '未定义的错误', 3);
                return res;
            }
        } else {
            return res
        }
    },
    err => {
        if (err && err.response) {
            switch (err.response.status) {
                case 400:
                    // err.message = '错误请求';
                    Toast.offline('错误', 1);
                    // Message.error('http版本不支持该请求');
                    break;
                case 401:
                    // err.message = '拒绝访问';
                    // Message.error('');
                    Toast.offline('拒绝访问', 1);

                    break;
                case 403:
                    // err.message = '拒绝访问';
                    // Message.error('');
                    Toast.offline('拒绝访问', 1);

                    break;
                case 404:
                    // err.message = '请求错误,未找到该资源';
                    // Message.error('');
                    Toast.offline('请求错误,未找到该资源', 1);

                    break;
                case 405:
                    // err.message = '请求方法未允许';
                    // Message.error('');
                    Toast.offline('请求方法未允许', 1);

                    break;
                case 408:
                    err.message = '请求超时';
                    // Message.error('');
                    Toast.offline('请求超时', 1);

                    break;
                case 500:
                    err.message = '服务器端出错';
                    // Message.error('');
                    Toast.offline('服务器端出错', 1);

                    break;
                case 501:
                    err.message = '网络未实现';
                    // Message.error('');
                    Toast.offline('网络未实现', 1);
                    break;
                case 502:
                    // err.message = '网络错误';
                    // Message.error('');
                    Toast.offline('网络错误', 1);
                    break;
                case 503:
                    // err.message = '服务不可用';
                    // Message.error('');
                    Toast.offline('服务不可用', 1);

                    break;
                case 504:
                    // err.message = '网络超时';
                    // Message.error('');
                    Toast.offline('网络超时', 1);

                    break;
                case 505:
                    err.message = 'http版本不支持该请求';
                    // Message.error(');
                    Toast.offline('http版本不支持该请求', 1);
                    break;
                default:
                    err.message = `连接错误${err.response.status}`
            }
        } else {
            // err.message = "连接到服务器失败";
            // Message.error('');
            Toast.offline('连接到服务器失败', 1);
        }
        // message.err(err.message)
        return Promise.reject(err)
    });

/**
 * 对请求结果的封装
 * @param promise 异步请求实例
 * @param callback 请求成功的回调处理
 * @param exceptionHandler 异常处理逻辑
 */
export function requestHandle (promise, callback, exceptionHandler) {
    promise.then(res => {
        //非异常的请求结果，交由回调处理
        if (res[R.code] === R.success || res[R.code] === R.fail) {
            callback(res);
        }
    }).catch(err => {
        if(!!exceptionHandler && typeof exceptionHandler === 'function'){
            exceptionHandler();
        }else {
            throw err;
        }
    });
}
export default axios;
